<!DOCTYPE html>
<!--[if lt IE 7]> <html class="no-js lt-ie9 lt-ie8 lt-ie7"> <![endif]-->
<!--[if IE 7]> <html class="no-js lt-ie9 lt-ie8"> <![endif]-->
<!--[if IE 8]> <html class="no-js lt-ie9"> <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js"> <!--<![endif]-->
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <title>JavaBase  &middot; sitename</title>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="HandheldFriendly" content="True">
<meta name="MobileOptimized" content="320">
<meta name="viewport" content="width=device-width, initial-scale=1">


<meta name="description" content="JavaBase description" />

<meta name="keywords" content="one, two, ">


<meta property="og:title" content="JavaBase  &middot; sitename ">
<meta property="og:site_name" content="sitename"/>
<meta property="og:url" content="https://lvzongcheng.gitee.io/java/javabase/" />
<meta property="og:locale" content="en-EN">


<meta property="og:type" content="article" />
<meta property="og:description" content="JavaBase description"/>
<meta property="og:article:published_time" content="2017-05-13T00:00:00Z" />
<meta property="og:article:modified_time" content="2017-05-13T00:00:00Z" />

  
    
<meta property="og:article:tag" content="one">
    
<meta property="og:article:tag" content="two">
    
  

  

<script type="application/ld+json">
  {
    "@context": "http://schema.org",
    "@type": "Article",
    "headline": "JavaBase",
    "author": {
      "@type": "Person",
      "name": "LvZongCheng"
    },
    "datePublished": "2017-05-13",
    "description": "JavaBase description",
    "wordCount":  985 
  }
</script>



<link rel="canonical" href="https://lvzongcheng.gitee.io/java/javabase/" />

<link rel="apple-touch-icon-precomposed" sizes="144x144" href="https://lvzongcheng.gitee.io/touch-icon-144-precomposed.png">
<link href="https://lvzongcheng.gitee.io/favicon.png" rel="icon">

<meta name="generator" content="Hugo 0.60.0" />

  <!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
<script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
<![endif]-->

<link href='https://fonts.googleapis.com/css?family=Merriweather:300%7CRaleway%7COpen+Sans' rel='stylesheet' type='text/css'>
<link rel="stylesheet" href="/css/font-awesome.min.css">
<link rel="stylesheet" href="/css/style.css">
<link rel="stylesheet" href="/css/highlight/default.css">

  
  
	<script>
	  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
	  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
	  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
	  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');

	  ga('create', 'Your Google Analytics tracking code', 'auto');
	  ga('send', 'pageview');

	</script>

</head>
<body>
  <main id="main-wrapper" class="container main_wrapper has-sidebar">
    <header id="main-header" class="container main_header">
  <div class="container brand">
  <div class="container title h1-like">
  <a class="baselink" href="https://lvzongcheng.gitee.io">
  LvZongCheng

</a>

</div>

  
<div class="container topline">
  
  淡定 执著 进取 自律


</div>


</div>

  <nav class="container nav primary no-print">
  

<a class="homelink" href="https://lvzongcheng.gitee.io">home</a>


  
<a href="https://lvzongcheng.gitee.io/framework" title="Show list of Frameworks">Frameworks</a>

<a href="https://lvzongcheng.gitee.io/java" title="Show list of Java">Java</a>

<a href="https://lvzongcheng.gitee.io/linux" title="Show list of Linux">Linux</a>

<a href="https://lvzongcheng.gitee.io/redis" title="Show list of Redis">Redis</a>

<a href="https://lvzongcheng.gitee.io/sql" title="Show list of SQL">SQL</a>

<a href="https://lvzongcheng.gitee.io/Spring" title="Show list of Spring">Spring</a>

<a href="https://lvzongcheng.gitee.io/tools" title="Show list of Tools">Tools</a>

<a href="https://lvzongcheng.gitee.io/webpage" title="Show list of WebPage">WebPage</a>

<a href="https://lvzongcheng.gitee.io/information" title="Show list of information">information</a>

<a href="https://lvzongcheng.gitee.io/network" title="Show list of network">network</a>

<a href="https://lvzongcheng.gitee.io/%E5%BE%AE%E6%9C%8D%E5%8A%A1" title="Show list of 微服务">微服务</a>

<a href="https://lvzongcheng.gitee.io/%E6%80%BB%E7%BB%93" title="Show list of 总结">总结</a>

<a href="https://lvzongcheng.gitee.io/%E6%9C%BA%E5%99%A8%E8%87%AA%E5%8A%A8%E5%8C%96" title="Show list of 机器自动化">机器自动化</a>

<a href="https://lvzongcheng.gitee.io/%E6%B1%87%E7%BC%96" title="Show list of 汇编">汇编</a>

<a href="https://lvzongcheng.gitee.io/%E8%AE%B0%E4%BA%8B%E6%9C%AC" title="Show list of 记事本">记事本</a>


</nav>

<div class="container nav secondary no-print">
  
<a id="contact-link-email" class="contact_link" rel="me" aria-label="Email" href="mailto:Lyc19880405@163.com">
  <span class="fa fa-envelope-square"></span></a>



<a id="contact-link-github" class="contact_link" rel="me" aria-label="Github" href="https://github.com/enten/hugo-boilerplate">
  <span class="fa fa-github-square"></span></a>




 


















</div>


  

</header>


<article id="main-content" class="container main_content single">
  <header class="container hat">
  <h1>JavaBase
</h1>

</header>

  <div class="container content">
  <h2 id="java-">Java 基础</h2>
<hr>
<hr>
<h3 id="heading">环境变量配置</h3>
<p>都是配置在环境变量中</p>
<p>示例：
1.|&ndash;JAVA_HOME=D:\Program Files (x86)\Java\jdk1.7.0</p>
<pre><code>|--path=%JAVA_HOME%\bin;
%SystemRoot%\system32;
%SystemRoot%;%SystemRoot%\System32\Wbem;
%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\
</code></pre>
<p>说明：路径改变只要改变JAVA_HOME的值就可以了而不用改变path</p>
<p>2.|&ndash;path=D:\Program Files (x86)\Java\jdk1.7.0;
%SystemRoot%\system32;
%SystemRoot%;%SystemRoot%\System32\Wbem;
%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\</p>
<p>3.|&ndash;classpath:
1.当类文件和编译过的文件在同一个文件同一个文件夹内可以不配置
2.classpath可以在DOM中临时配置，也可以在环境变量中永久配置
示例：</p>
<h5 id="set">临时配置环境变量set</h5>
<p>1.Set能（查看/设置）环境变量的值
2.Dos中配置的环境变量只对当前窗口有效，关闭消失
3.配置环境变量的Dos窗口未关闭，而在Dos窗口中用start命令打开新Dos窗口，在这个新窗口中，
环境变量仍有效4.在原有环境变量上加新值；（值；%环境变量名%）</p>
<p>示例：
查看环境变量path的值
set path</p>
<pre><code>设置环境变量path的值
set path=路径
</code></pre>
<hr>
<h3 id="jarjarjar">打jar包（静态jar包和可执行jar包）</h3>
<p>jar包包括两种：静态jar包和可执行jar包</p>
<h5 id="jar">静态jar包</h5>
<p>首先选中项目，点击右键-&gt;Export,弹出如下窗口：<br>
<img src="/image/Java/20170901-01.png" alt="Alt text"><br>
选择JAR file后点击Next,弹出如下窗口：<br>
<img src="/image/Java/20170901-02.png" alt="Alt text"><br>
最后点Finish即可。</p>
<h5 id="jar1">可执行jar包</h5>
<p>前面跟打静态jar包一样，选中项目，点击右键,弹出窗口：<br>
<img src="/image/Java/20170901-03.png" alt="Alt text"><br>
点击next后，弹出另外一个窗口：<br>
<img src="/image/Java/20170901-04.png" alt="Alt text"></p>
<h6 id="heading1">注意事项：</h6>
<ol>
<li>首先要确保程序可执行，然后才能打成可执行jar包</li>
<li>选择主目录，也就是主程序运行接口的时候有可能列表中没有，这是因为必须把可执行程序执行一遍</li>
<li>有时候打的可执行jar包并不一定能正常运行，这时候可以在library handling项里面选择其他加载类库的模式</li>
<li>测试打好的可执行jar包是否能运行：
进入cmd命令行，切换到当前目录，执行命令：Java -jar jar包名.jar</li>
</ol>
<hr>
<h3 id="heading2">数据类型</h3>
<h6 id="heading3">基本数据类型:</h6>
<p>简单数据类型是不能简化的、内置的数据类型、由编程语言本身定义，它表示了真实的数字、字符和整数。</p>
<h6 id="heading4">引用数据类型：</h6>
<p>从基本类型构造而来的类和其他复杂数据类型。
如:类、接口、数组和字符串。这种类型的变量
并不包含类型的实例，而只是包含对实例的引用。</p>
<p>引用类型的内存单元中只存放对象的地址，而对
象本身存贮在内存堆中，只是简单的引用对象的地址</p>
<h6 id="heading5">区别</h6>
<p>基本数据类型和引用类型的区别主要在于基本数据类
型是分配在栈上的，而引用类型是分配在堆上的（需要java中的栈、堆概念），</p>
<h5 id="heading6">堆栈</h5>
<p>栈 - 有编译器自动分配释放<br>
堆 - 一般由程序员分配释放</p>
<p>栈堆区别
连续内存单元，越界就访问其他内存单元。
堆是零散内存根据线性组合起来的</p>
<p>栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。</p>
<h6 id="heading7">栈</h6>
<p>栈空间是内存空间的一部分，它只是一段可以以一种特殊的方式进
行访问的内存空间。
有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入
栈出栈的操作。这种机制的特点是效率高，支持的数据有限，一般
是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持
其他的数据结构</p>
<h6 id="heading8">堆</h6>
<p>堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，
而是由函数库提供的。基本的malloc/realloc/free函数维护了一套
内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，
这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以
使用的内存空间，则试图利用系统调用来动态增加程序数据段的内
存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适
当的形式返回给调用者。当程序释放分配的内存空间时，这片内存
空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空
间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复
杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这
套机制有如下若干原因：</p>
<ol>
<li>系统调用可能不支持任意大小的内存分配。</li>
<li>系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。</li>
<li>没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。</li>
</ol>
<h6 id="heading9">堆和栈的对比</h6>
<p>栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵
活；而堆是函数库提供的功能，特点是灵活方便，数据适应面广泛，
但是效率有一定降低。栈是系统数据结构，对于进程/线程是唯一的；
堆是函数库内部数据结构，不一定唯一。不同堆分的内存无法互相操
作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，
比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态
分配无需释放(是自动)，也就没有释放函数。为可移植的程序起见，
栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程
序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释
放内存匹配是良好程序的基本要素</p>
<p>栈和堆中主要放置了四种类型的数据：值类型(Value Type)，引用类型(Reference Type)，指针(Pointer)，指令(Instruction)。</p>
<hr>
<h3 id="heading10">变量笔记</h3>
<h5 id="heading11">成员变量和局部变量</h5>
<p>成员变量和局部变量：
1.作用范围
成员变量作用于整个类中。
局部变量作用于函数中，或者语句中。
2.在内存中的位置：
成员变量：在堆内存中，因为对象的存在，才在内存中存在。
局部变量：存在栈内存中。</p>
<h5 id="heading12">匿名对象应用</h5>
<p>匿名对象使用方式一：当对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员调用，必须给这个对象起个名字。
匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。</p>
<p>强引用，若引用，软引用，虚引用；是真对优化内存用的</p>
<h5 id="heading13">封装</h5>
<p>封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
将变化隔离
便于使用
提高重用性
提高安全性
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。</p>
<hr>
<h3 id="heading14">帮助文档制作</h3>
<hr>
<p>javadoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等<br>
注释形成一个和源代码配套的API帮助文档。也就是说，只要在编写程序时以一<br>
套特定的标签作注释，在程序编写完成后，通过Javadoc就可以同时形成程序的<br>
开发文档了。</p>
<p>javadoc命令是用来生成自己API文档的，<br>
使用方式：在dos中在目标文件所在目录输入javadoc +文件名.java。</p>
<p>java帮助文档用javadoc命令<br>
java的说明书通过文档注释来完成<br>
类要是公共的即（public修饰的）<br>
详细请看javadoc注释<br>
@author 作者<br>
@version 版本</p>
<p>一、利用Myeclipse都可轻松制作javadoc</p>
<p>利用Myeclipse生产javadoc文档的步骤如下：</p>
<p>1.选择File-&gt;Export-&gt;javadoc，下一步。</p>
<p>2.Javadoc comand选择JDK的bin目录下的javadoc.exe。选择要生成的源代码和javadoc保存的目的路径，下一步。</p>
<p>3.Document title输入标题，下一步。</p>
<p>4.Extra Javadoc options输入</p>
<p>-windowtitle &lsquo;Type B Monitor&rsquo;[浏览器显示标题]</p>
<p>-bottom &lt;center&gt;Travelsky&lt;/center&gt;[底部显示文本]，</p>
<h6 id="heading15">常用标记</h6>
<p>标签			说明		JDK 1.1 	doclet	标准doclet	标签类型<br>
@author 	作者		作者标识		√	√	包、 类、接口</p>
<p>@version 版本号		版本号		√	√	包、 类、接口</p>
<p>@param 	参数名 描述	方法的入参名及描述<br>
信息，如入参有特别<br>
要求，可在此注释。	√	√	构造函数、 方法</p>
<p>@return 	描述		对函数返回值的注释	√	√	方法</p>
<p>@deprecated 过期文本	标识随着程序版本的<br>
提升，当前API已经<br>
过期，仅为了保证兼<br>
容性依然存在，以此<br>
告之开发者不应再用<br>
这个API。		√	√	包、类、接口、值域、构造函数、 方法<br>
@throws	异常类名		构造函数或方法所会<br>
抛出的异常。	　　	√	构造函数、 方法</p>
<p>@exception 异常类名		同@throws。	√	√	构造函数、 方法</p>
<p>@see 	引用		查看相关内容，如类、<br>
方法、变量等。	√	√	包、类、接口、值域、构造函数、 方法</p>
<p>@since 	描述文本		API在什么程序的什<br>
么版本后开发支持。	√	√	包、类、接口、值域、构造函数、 方法</p>
<p>{@link	包.类#成员 标签}	链接到某个特定的成<br>
员对应的文档中。	　　	√	包、类、接口、值域、构造函数、 方法</p>
<p>{@value}			当对常量进行注释时，<br>
如果想将其值包含在文<br>
档中，则通过该标签来<br>
引用常量的值。	　　	√(JDK1.4)	静态值域<br>
@date 日期<br>
@parameter 参数及其意义<br>
@see reference 查看引用<br>
此外还有@serial、@serialField、@serialData、{@docRoot}、{@inheritDoc}、{@literal}、{@code} {@value arg}<br>
几个不常用的标签，由于不常使用，我们展开叙述，感兴趣的读者可以查看帮助文档。</p>
<p>Javadoc命令格式如下： 
javadoc [选项] [软件包名称] [源文件]</p>
<h6 id="heading16">其中选项有：</h6>
<ul>
<li>overview &lt;文件&gt; 读取 HTML 文件的概述文档</li>
<li>public 仅显示公共类和成员</li>
<li>protected 显示受保护/公共类和成员（默认）</li>
<li>package 显示软件包/受保护/公共类和成员</li>
<li>private 显示所有类和成员</li>
<li>help 显示命令行选项并退出</li>
<li>doclet &lt;类&gt; 通过替代 doclet 生成输出</li>
<li>docletpath &lt;路径&gt; 指定查找 doclet 类文件的位置</li>
<li>sourcepath &lt;路径列表&gt; 指定查找源文件的位置</li>
<li>classpath &lt;路径列表&gt; 指定查找用户类文件的位置</li>
<li>exclude &lt;软件包列表&gt; 指定要排除的软件包的列表</li>
<li>subpackages &lt;子软件包列表&gt; 指定要递归装入的子软件包</li>
<li>breakiterator 使用 BreakIterator 计算第 1 句</li>
<li>bootclasspath &lt;路径列表&gt; 覆盖引导类加载器所装入的类文件的位置</li>
<li>source &lt;版本&gt; 提供与指定版本的源兼容性</li>
<li>extdirs &lt;目录列表&gt; 覆盖安装的扩展目录的位置</li>
<li>verbose 输出有关 Javadoc 正在执行的操作的消息</li>
<li>locale &lt;名称&gt; 要使用的语言环境，例如 en_US 或 en_US_WIN</li>
<li>encoding &lt;名称&gt; 源文件编码名称</li>
<li>quiet 不显示状态消息</li>
<li>J&lt;标志&gt; 直接将 &lt;标志&gt; 传递给运行时系统</li>
<li>d指定路径，用于将生成的API文档放到指定目录下</li>
<li>wndowtitle 指定一个字符串，设置API文档浏览器窗口标题</li>
<li>doctile指定一个HTML格式的文本，用于指定概述页面的标题</li>
</ul>
<hr>
<h3 id="heading17">匿名内部类</h3>
<hr>
<ol>
<li>
<p>成员位置的内部类，可以被成员修饰符修饰，内部类可以直接使用外部类成员<!-- raw HTML omitted --></p>
<p>调用内部类方法三种格式：<!-- raw HTML omitted -->
外部类.内部类 变量名 = new 外部类().new内部类();<!-- raw HTML omitted -->
内部类，内部类方法，都是非静态<!-- raw HTML omitted --></p>
<p>外部类.内部类.方法()<!-- raw HTML omitted -->
内部类静态，内部类方法静态<!-- raw HTML omitted --></p>
<p>外部类.内部类 变量 = new 外部类.内部类();<!-- raw HTML omitted -->
内部类静态，内部类方法非静态<!-- raw HTML omitted --></p>
</li>
<li>
<p>局部位置内部类<!-- raw HTML omitted -->
运行局部位置内部类，必须依靠外部类中的方法，这个方法中创建内部类对象<!-- raw HTML omitted --></p>
</li>
</ol>
<pre><code>局部位置内部类，访问局部变量加final,原因是生命周期问题&lt;br /&gt;
final的方法，巧妙的解决的生命周期，因为加final之后，变量变成常量，&lt;br /&gt;
不会在改变，于是在编译时期，已将这个值赋值给访问者&lt;br /&gt;
</code></pre>
<ol start="3">
<li>
<p>匿名内部类<!-- raw HTML omitted -->
匿名内部类，是一种简化形式，简化子类或者实现类的一种写法<!-- raw HTML omitted -->
格式：<!-- raw HTML omitted -->
new 接口或者父类(){
重写方法
}.方法();</p>
<p>当需要多个方法时，格式为：<!-- raw HTML omitted -->
接口或者父类 变量 = new 接口或者父类(){<br>
重写多个方法<br>
};<br>
变量.方法();<br>
变量.方法();</p>
</li>
</ol>
<pre><code>-----------
### 基础加强
-----------
</code></pre>
<h6 id="heading18">静态代码块</h6>
<p>格式：
static
{
静态代码块中的执行语句。 
}
特点：随着类的加载而执行，只执行一次，并优先于主函数，用于
给类进行初始化的。</p>
<h6 id="this">this</h6>
<p>this指当前运行类。即被new的类
super()：调用父类无参构造方法</p>
<h6 id="heading19">泛型应用</h6>
<p>泛型：就是允许在定义类、接口、方法时使用类型形参，这个型参将在声明变量、创建对象、调用方
法时动态的指定（即传人实际的类型参数，也可以为类型实参）。
注：在静态方法、静态初始化块或者静态变量的声明和初始化中不允许使用泛型形参。</p>
<p>1.泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器档住源程序中的非法输入，在编译
时发现输入的其他类型的数据，防止错误。当从集合中获取一个对象时，编译器可以知道这个对象的类型，
不需要对对象进行强制类型转换。
可以理解成：（泛型的作用是在定义集合时，明确表示你要向集合中装载那种类型的数据，无法加入指定类型
以外的数据）</p>
<p>2.编译器编译带类型说明的集合时会去掉类型信息即“去类型化”，使程序运行效率不受影响，对于参数化的泛
型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能过
编译器，就可以往某个泛型集合中加人其他类型的数据，例如，用反射得到集合，再调用其add方法即可。
（ 例：ArrayList&lt;Integer&gt; collection3=new ArrayList&lt;Integer&gt;();//只能加入整型
//通过反射往collection3加入字符串
collection3.getClass().getMethod(&ldquo;add&rdquo;,Object.class).invoke(collection3,&ldquo;abc&rdquo;) ）</p>
<p>3.ArrayList&lt;E&gt;类定义和ArrayList&lt;Integer&gt;类引用中涉及如下术语：
(1) 整个称为ArrayList&lt;E&gt;泛型类型
(2) ArrayList&lt;E&gt;中的E称为类型变量或类型参数
(3) 整个ArrayList&lt;Integer&gt;称为类型参数的实例或实际类型参数
(4) ArrayList&lt;Integer&gt;中的&lt;&gt;念typeof
(5) ArrayList称为原始类型</p>
<p>4.参数化类型与原始类型的兼容性：
(1) 参数化类型可以引用一个原始类型对象，编译报告警告，例如
Collection&lt;String&gt;c=new Vector();
(2)原始类型可以引用一个参数化类型对象，编译报告警告，例如
Collection c=new Vector&lt;string&gt;();
(3)参数化类型不考虑类型参数的继承关系。
Vector&lt;String&gt;v=new Vector&lt;Object&gt;();//错误，不明确具体加人何种类型，范围不同
Vector&lt;Object&gt;v=new Vector&lt;String&gt;();//错误，
(4)在创建数组实例时，数组的元素不能使用参数化类型
Vector&lt;Integer&gt;vectorList[]=new Vector&lt;Integer&gt;[10];//错误</p>
<p>5.泛型通配符
?：通配符可以引用其他各种参数化的类型，？通配符定义的变量要用作引用，可以调用
与参数化无关的方法，不能调用与参数化有关的方法。
通配符的限定（泛型限定）
&lt;? extends E&gt;可以接收E类型或者E类型的子类型，向上限定。
|——为类型形参设定多个上限（最多有一个父类上限，可以有多个接口上限）
//表明T类型必须是Number类或其子类，并必须实现java.io.Serializable接口
例：public class Apple&lt;T extends Number &amp; java.io.Serializable&gt;
{  &hellip;..}</p>
<pre><code>&amp;lt;? super E&gt;可以接受E类型或者E类型的父类型，向下限定
</code></pre>
<p>6.泛型方法
格式：
修饰符 &lt;T ,S&gt;返回值类型 方法名（形参列表）{//方法体 }
修饰符 &lt;T ,S&gt;返回值类型 E 方法名（形参列表）{//方法体 }
7.泛型类
格式：修饰符 class 类名&lt;E&gt;
{
pulic &lt;T&gt; T one(T t){}
public&lt;T&gt; void two(T t){}
}
保证类中方法体所用泛型参数一致
8.泛型接口
格式；
类型 interface 类名&lt;E&gt;
9.泛型构造器
允许在构造器中声明类型形参，产生泛型构造器。
java7菱形语法：允许调用构造器时在构造器后使用一对尖括号来代表泛型信息。</p>
<h6 id="heading20">可变参数的特点：</h6>
<p>1.只能出现在参数列表的最后；
2. &hellip;位于变量类型和变量名之间，前后有无空格都可以。
调用可变参数的方法时，编译器为该可变参数隐含创建一个
数组，在方法体中以数组的形式访问可变参数。</p>
<h6 id="for">强for循环</h6>
<p>语法：
for（type 变量名：集合变量名）{   }
1.迭代变量必须在（）中定义；
2.集合变量可以是数组或实现了Iterable接口的集合类；</p>
<h6 id="heading21">自动拆装箱及享元模式</h6>
<p>自动拆箱和装箱
自动拆箱和装箱就是将基本数据类型转换成引用数据类型
Integer i1=12;
Integer i1=12;
他们是同一个</p>
<pre><code>Integer i1=130;
Integer i2=130;
</code></pre>
<p>他们不是同一个
说明：在-128 到+128，存储为一个字节，数字小使用频率比较高，当下次用时先调用存储的，
这样节省存储空间。</p>
<p>享元模式：有很多小的对象，它们有很多相同的东西，把它们相同的东西变成一个对象，把
不同的变成外部的东西，作为方法的参数传人。</p>
<h5 id="c">枚举（学自c++）</h5>
<p>enum是关键字：</p>
<p>什么是枚举：
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器
就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变
量的方式在开发阶段无法实现这一目标。</p>
<p>用普通类如何实现枚举功能：
(1).私有构造方法；
(2).每个元素分别用有个公有的静态成员变量表示；
(3).可以有若干公有方法或抽象方法；</p>
<p>1.枚举相当于一个类，可以定义构造方法、成员变量、普通方法和抽象方法。
2.一个Java源文件中最多只能定义一个Public访问权限的枚举类，且该Java
3.文件必须和该枚举类的类名相同。
4.使用enum定义的非抽象的枚举类默认会使用final修饰，不能派生子类。
5.枚举元素必须位于枚举体的开始部分，枚举元素列表后用分号与其它成员分隔。</p>
<p>枚举类格式：
enum 与class 和 interface作用相似
public enum 类名
{
//在第一行列出枚举实例
//以英文逗号（,）分隔，以分号结束（;）
}
带有构造方法的枚举
public enum 类名
{
枚举实例1(参数),枚举实例2（参数);
private 类名(参数){代码};</p>
<pre><code>}
</code></pre>
<p>实现带有抽象方法的枚举
public enum 类名
{
枚举实例1
{
public 返回值 方法名
},
枚举实例2
{
public 返回值 方法名
}；
public abstract 返回值 方法名()；</p>
<pre><code>}
</code></pre>
<p>注：带有抽象方法和构造方法的枚举没有试过
注意：
带构造方法的枚举：构造方法必须定义成私有；</p>
<p>枚举只有一个成员时，就可以作为一种单例的实现方式。</p>
<p>总结：
枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象。</p>
<h5 id="heading22">反射</h5>
<p>反射就是把Java类中的各种成分映射成相应的java类
每个类被加载之后，系统就会为该类生成一个对应的Class对象。
（一个class就是一段字节码）
在JAVA中获得Class对象有三种方式:
1.使用Class类的forName(String clazzName)静态方法。（完整类名）
例：Class clazz=Class.forName(&quot;&quot;);
2.调用某个类的class属性来获取该类对应的Class对象</p>
<p>3.调用某个类的getClass()方法。（根据实例获得）</p>
<p>第二种代码更安全，程序性能更安全。
一个Java类用一个Class类的对象来表示；一个类中的
组成部分：成员变量、方法、构造方法、包等等信息也
用一个个的Java类来表示。表示java类的class类提供一
系列的方法来获得所表示的信息，这些信息就是用相应类
的实例对象来表示，它们是Field Method Contructor Package
等等
Methoe：(Method:类代表某个类中的一个成员方法) 
Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。
所反映的方法可能是类方法或实例方法（包括抽象方法）。
1.得到类中的某一个方法：
<!-- raw HTML omitted --><!-- raw HTML omitted -->Method charAt= Class.forName(&ldquo;java.long.String&rdquo;).getMethod(&ldquo;charAt&rdquo;,int.class)；		<!-- raw HTML omitted --><!-- raw HTML omitted -->
2.调用方法：<br>
通常方式：System.out.println(str.charAt(1));<br>
反射方式：System.out.println(charAt.invoke(str,1));<br>
如果传递给Method对象的invoke()方法的一个参数为null，说明该
method对象对应的是一个静态方法</p>
<p>Field：（成员变量反射）Field类代表某个类中的一个成员变量
Field 提供有关类或接口的单个字段（成员变量）的信息，以及对它的动态访问权限。
反射的字段可能是一个类（静态）字段或实例字段。
getField(只能提供可见字段)
getDeclaredField（只要是里面声明过的字段就可以看见，但取不到值）
想获取值可以设置setAccessible(true)，就可以获取他的值
示例代码：(<code>暴力反射</code>)</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<pre><code>注：字节码比较用等号和用equest都可以（但用等号比较好一些）。

示例代码：  
&lt;pre&gt;&lt;code&gt;  
public class ReflectPonint {
private int x;
public  int y;
public ReflectPonint(int x, int y) {
    super();
    this.x = x;
    this.y = y;
}
}
//
ReflectPonint pt1=new ReflectPonint(3,5);
    Field fieldY=pt1.getClass().getField(&quot;y&quot;);
    int y=(Integer) fieldY.get(pt1);
    System.out.println(y);
//暴力反射
Field fieldx=pt1.getClass().getDeclaredField(&quot;x&quot;);//可以看见但取不到值
    fieldx.setAccessible(true);//设置成true,就可以获得私有类型的值了
    int x=(Integer) fieldx.get(pt1);
    System.out.println(x);
&lt;/code&gt;&lt;/pre&gt;
</code></pre>
<p>Constructor：Constructor 提供关于类的单个构造方法的信息以及对它的访问权限。<br>
1.得到某一个类所有的构造方法：</p>
<!-- raw HTML omitted -->
<pre><code>2.得到某一个构造方法
</code></pre>
<!-- raw HTML omitted -->
<pre><code>//获得方法时要用到类型  
3.创建实例对象方式  
&lt;pre&gt;&lt;code&gt;	
  //1.通常方式：
    String str=new String(new StringBuffer(&quot;abc&quot;));
    //2.反射方式: 
    String str=constructor.newInstance(new StringBuffer(&quot;abc&quot;)); 
</code></pre>
<p><!-- raw HTML omitted --><!-- raw HTML omitted -->		
//调用获得的方法时要用到上面相同类型的实例对象<br>
4.Class.newInstance()方法：</p>
<!-- raw HTML omitted -->
<pre><code>该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。  
用到了缓存机制来保存默认构造方法的实例对象。  

示例代码：（和注释的结果相同）
//new String(new StringBuffer(&quot;abc&quot;));
获取String的String(StringBuffer buffer)构造方法
Constructor&amp;lt;String&gt; constructor = String.class.getConstructor(StringBuffer.class);
实例化该构造方法
String str=constructor.newInstance(new StringBuffer(&quot;abc&quot;));
System.out.println(str);
</code></pre>
<p>Package：Package 对象包含有关 Java 包的实现和规范的版本信息。通过用于加载类
的 ClassLoader 实例，可以获取并获得此版本信息。</p>
<h6 id="-class">反射的基石 Class类</h6>
<p>一个class代表一个字节码
一个Method代表一个字节码中的方法
Constructor类代表一个字节码中的一个构造方法(Constructor类代表某个类中的一个构造方法 )
Field 类代表某个类中的一个成员变量（<code>暴力反射</code>）</p>
<p>通过反射获得泛型的参数化类型
通过泛型类型自己是无法知道所接收的参数类型，将变量交给一个方法去使用。在通过这
个方法的泛型方法来获取参数类型来获得泛型类型的参数类型。
例：</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<h5 id="javabean">javaBean</h5>
<h6 id="heading23">简单内省：</h6>
<p>导入：import java.beans.PropertyDescriptor;</p>
<p>PropertyDescriptor pd=new PropertyDescriptor(类中属性，类名.getClass);//把类当成javaBean
这个类要遵循的书写规则：</p>
<p>javaBean:是一种特殊的java类，主要用于两个模块之间传递多个数据信息，
将这些信息封装到一个javaBean中.这种java对象通常称之为值对象
（Value Object,简称VO）。
这种java类的方法主要用于访问私有的字段，且方法名符合某种命名规则(一般以小写get或set打头
的方法，有以get或set打头的方法的类就可以当作javaBean来使用)。get
或set方法是留跟外界操作的</p>
<h6 id="heading24">命名规则：</h6>
<p>去掉前缀，如果剩余部分第二个字母为小写的，则把剩余部分的首字母改
成小写，相反者不改写。
一个类被当作javaBean使用时，javaBean的属性是根据方法名推断出来的，
它根本看不到java类内部的成员变量。</p>
<h6 id="heading25">内省：</h6>
<p>new PropertyDescriptor对象的方式来了解JavaBean API的价值，先用一段
代码读取JavaBean的属性，然后再用一段代码设置JavaBean的属性。</p>
<p>乱码：</p>
<p>BeanUtils工具包使用
|&ndash;//javaBean的封装工具类,将类封装到bean中
|&ndash;BeanUtils.populate(实例化类名, Map&lt;String,String[]&gt;);</p>
<h5 id="annotation">注解annotation</h5>
<p>在java.lang的最后，最基本的类
注解相当于一种标记，在程序中加了注解就相当于为程序打上了某种标记。
以后javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元
素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加在包，
类，字段，方法，方法的参数以及局部变量上。</p>
<p>注解就相当于一个你的源程序中调用一个类，要在源程序中应用某个注解，得
先准备好了这个注解类。就像你要调用某个类，得先有开发好这个类。</p>
<p>四个基本注解（Annotation）
@Override(jdk5.0)限定重写父类方法，（jdk6.0）可以是实现父接口
@Deprecated标示已过时
@SuppressWarnings仰止编译器警告，有参数。
@Safe Varargs堆污染警告（堆污染是把一个不带泛型的对象赋给一个带泛型的变量出现的错误）</p>
<p>@Retention指定注解可以保留多长时间
@Target指定注解能用于修饰哪些单元
@Documented指定注解类将被javadoc工具提取成文档
@Inherited 使注解具有继承性</p>
<p>自定义注解
注解类：默认public abstract</p>
<p>public @interface Test
{
代码和接口一样，使用default赋初始值。
例： 
int age() default 32;
}</p>
<p>@interface A
{</p>
<pre><code>返回值类型:基本类型，字符串，Class，Annotation，Enum类 以及以上类型的一维数组。
</code></pre>
<p>}</p>
<p>应用了“注解类”的类
@A
Class B
{
}
对“应用了注解类的类”进行反射操作的类
Class C
{
B.Class.isAnntionPresent(A.class)
A a=B.class.getAnnotion(A.class);
}
注解的生存周期
@Retention元注解，其三种取值：
RetetionPolicy.SOURCE、RetetionPolicy.CLASS、RetetionPolicy.RUNTIME;
分别对应：java源文件&ndash;class文件&mdash;内存中的字节码。</p>
<p>元注解以及其枚举属性值，查基本API文档或直接看java.lang.annotation包下面的类</p>
<h6 id="heading26">类加载器</h6>
<p>将类加载到内存中</p>
<p>系统默认三个主要类加载器的，每个类负责加载特定位置的类： 
BootStrap,ExtClassLoader,AppClassLoader 
类加载器也是JAVA类，因此其他是JAVA类的类加载器本身也要被类加载器加载，显然必须 
有一个类加载器是java类，这正是BootStrap。是嵌套在JAVA虚拟机里面的。
BootStrap:是java虚拟机中的第一个类加载器，它不是java类，是由c++写的二进制代码， 
嵌套在java虚拟机内核中，随着虚拟机的启动而启动，不需要类加载器加载。 
ExtClassLoader: 
AppClassLoader:</p>
<p>类加载器之间的父子关系和管辖范围图
BootStrap——（JRE/lib/rt.jar） 
|<br>
ExtClassLoader——(JRE/lib/ext/*。jar)扩展类加载器<br>
|<br>
AppClassLoader——（CLASSPATH指定的所有jar或目录）应用类加载器</p>
<p>类加载器是采用父子关系的树形结构进行组织</p>
<p>类加载器的委托机制： 
当JAVA虚拟机要加载一个类时，到底派出哪个类加载器去加载。</p>
<p>1.首先当前线程的类加载器去加载线程中的第一个类<br>
2.如果类A中引用了类B,JAVA虚拟机将使用加载类A的类装载器来加载类B。
3.还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。</p>
<p>每个类加载器加载类时，又先委托给其上级类加载器。
1.当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛出ClassNotFoundException,不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，也应为太多不知道找那一个。</p>
<p>ClassLoader   loader= 类.class.getClassLoader();<br>
|&ndash;getClassLoader()返回该类的类加载器<br>
loader.getParent();<br>
|&ndash;getParent()返回委托的父类加载器</p>
<p>自定义类加载器：<br>
ClassLoader的实现类</p>
<p>编写自己的类加载器<br>
知识点：<br>
1.定义自己的类加载器必须继承ClassLoader<br>
2.loadClass方法与findClass方法<br>
|——loadClass找父类加载器逐级往上<br>
|——findClass在本类查找不需要从顶端向下查找。 
3.defineClass方法<br>
编写步骤：<br>
1.编写一个对文件内容进行简单加密的程序。
2.编写一个自己的类加载器，可以实现对加密过的类进行装载和解密。
3.编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为<br>
编译器无法识别这个类，程序中可以除了使用ClassLoader.load方法外，还可以使用<br>
设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName.</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<p>=================================================</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<h5 id="heading27">代理</h5>
<h6 id="heading28">一、静态代理</h6>
<ol>
<li>要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能。</li>
<li>编写一个与目标类具有相同接口的代理类，代理类的每个方法都调用目标
类的相同方法，并在调用方法时加上系统功能的代码。</li>
<li>如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在
配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志
功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段
时间后，又想去掉系统功能也很容易。</li>
</ol>
<h6 id="aop">二、AOP</h6>
<ol>
<li>
<p>系统中存在交叉业务，一个交叉业务就是要切人到系统中的一个方面。
安全     事物     日志<br>
StudentService  &mdash;&ndash;|&mdash;&mdash;&ndash;|&mdash;&mdash;&ndash;|&mdash;&mdash;-<br>
courseService   &mdash;&ndash;|&mdash;&mdash;&ndash;|&mdash;&mdash;&ndash;|&mdash;&mdash;-<br>
MiscService     &mdash;&ndash;|&mdash;&mdash;&ndash;|&mdash;&mdash;&ndash;|&mdash;&mdash;-</p>
</li>
<li>
<p>用具体的程序代码描述交叉业务：<br>
method1    method2     method3<br>
{          {           {<br>
&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;切面<br>
&hellip;..        &hellip;&hellip;      &hellip;&hellip;.<br>
&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;切面<br>
}          }           }</p>
</li>
<li>
<p>交叉业务的编程问题即为面向方面的编程（Aspect oriented program,简称AOP），AOP
的目标就是要使交叉业务模块化，可以采用将切面代码移动到原始方法的周围，这与直接
在方法中编写切面代码的运行效果是一样的，如下所示：</p>
</li>
</ol>
<h6 id="heading29">三、动态代理技术</h6>
<p>JDK提供工具类Proxy，在运行时创建代理对象
其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。</p>
<p><strong>装饰者设计模式</strong>：必须有接口。必须实现接口中的所有方法<br>
<strong>动态代理</strong>：必须有接口，只执行指定的方法，其他的默认执行</p>
<p>1.要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用
静态代理方式，将是一件非常麻烦的事情。<br>
2.JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作具有
相同接口的目标类的代理。<br>
虚拟机在内存中动态生成出的类，没有通过类加载器加载，就没有加载class，
在创建时就必须要指定一个类加载器，
3.JVM生成的动态类必须实现一个或多个接口，所以JVM生成的动态类只能用作具
有相同接口的目标类的代理<br>
4.CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理。所以
可以使用CGLIB库为一个没有实现接口的类生成动态代理类。<br>
5.代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还
可以在代理方法中如下四个位置加上系统功能代码：<br>
1.）调用目标方法之前<br>
2.）调用目标方法之后<br>
3.）在调用目标方法前后<br>
4.）在处理目标方法异常的catch块中</p>
<h6 id="java-api">动态紧密关联的Java API</h6>
<ol>
<li>java.lang.reflect.Proxy:这是java动态代理机制生成的所有动态代理类的父类，
他提供了一组静态方法来为一组接口动态的生成代理类及其对象。</li>
<li>java.lang.reflect.InvocationHandler:调用处理器接口，自定义invoke方法，用于
集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。</li>
<li>java.lang.ClassLoader:类装载器类，负责将类的字节码装载到Java虚拟机（JVM）中
并为其定义类对象，然后该类才能使用。与普通类唯一区别是字节码是由JVM在运行时动
态生成的，而不是预存在任何一个.class文件中。每次生成动态代理类对象时都需要指定
一个类装载器对象。</li>
</ol>
<h6 id="heading30">实现动态代理的步骤：</h6>
<ol>
<li>实现InvocationHandler接口，创建自己的调用处理器。</li>
<li>给Proxy类提供ClassLoader和代理接口类型数组，创建动态代理类。</li>
<li>以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数。</li>
<li>以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象。</li>
</ol>
<p>Object proxyObj = Proxy.newProxyInstance(1,2,3);
参数1：ClassLoader ，用于将代理类加载内存中，一般当前类类加载器。例如：Xxxx.class.getClassLoader();
参数2：Class[] interfaces ，确定代理需要实现接口们。
方式1：userService.getClass().getInterfaces();
方式2：new Class[]{ UserService.class }
参数3：InvocationHandler 执行处理类，用于编写逻辑代码
实现方式：invoke(Object proxy,Method method,Object[] args) ，代理对象每一个方法执行时，此方法都将触发
参数31：proxy：代理对象本身
参数32：method：当前执行的方法
* 获得当前执行的方法名称：method.getName()
* 执行目标方式：method.invoke(args)
参数33：args：当前方法实际参数</p>
<p><strong>代码：</strong>  
proxy 此类表示代理设置</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->

</div>


  
</article>
      <footer id="main-footer" class="container main_footer">
  

  <div class="container nav foot no-print">
  
<a href="https://lvzongcheng.gitee.io/license">license</a>


  <a class="toplink" href="#">back to top</a>

</div>

  <div class="container credits">
  
<div class="container footline">
  
  code with <!-- raw HTML omitted --><!-- raw HTML omitted -->


</div>


  
<div class="container copyright">
  
  (c) 2015 yourname.


</div>


</div>

</footer>

    </main>
    
<script type="text/javascript">
  (function() {
    
    
    if (window.location.hostname == "localhost")
      return;
    var dsq = document.createElement('script'); dsq.async = true; dsq.type = 'text/javascript';
    dsq.src = '//your_disqus_shortname.disqus.com/count.js';
    (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
  })();
</script>



<script src="/js/highlight.pack.js"></script>
<script>hljs.initHighlightingOnLoad();</script>



    
  </body>
</html>

